In real-time network computing environments, a plurality of hosts typically must share one or more pieces of dynamic information. This shared state might include traditional publish-subscribe data such as stock quotes or news headlines. It might include dynamic information, such as content of an HTML page. In collaborative environments, the shared information might simply describe the presence or absence of other pieces of shared information.
In most cases, this shared state is managed by a server host, and client hosts can update the state and learn about its current value. Such traditional client-server systems have used either full-caching or no-caching to implement distributed state management.
Full-caching systems replicate all shared data locally at all of the clients. Whenever the data changes, the server transmits an update notification to all of the clients informing them to update their local data caches. All client application requests to read data are consequently handled by accessing the local cache, thereby gaining low request-response latency at the cost of significant network bandwidth consumption whenever an update occurs. Existing protocols such as the Lotus Notification Service Transport Protocol (NSTP) and IBM Interactive Universe (InVerse) server employ this approach.
No-caching systems maintain no state locally at the client and rely on a server interaction to perform all client application read and write requests. These systems only transmit the data that is specifically needed by each client at the expense of slower application response time and at the risk of potentially transmitting the same information multiple times over the network to a client. Most World-Wide Web applications employ this approach.
These two techniques require the system to choose an extreme between high network bandwidth consumption and fast client response time. However, in many environments, neither of these extremes is desirable. This is particularly true in synchronous groupware systems that must simultaneously support interactive response time and manage considerable amounts of shared state. Previous systems that have attempted to merge these two extremes have simply opted to statically mark some data as fully-cached and mark the remaining data as non-cached. However, this hybrid approach does not account for the fact that different clients manipulate different information, meaning that each client demands a different prioritization of interactive response time and bandwidth consumption on each piece of shared information
Therefore, a need exists for a method and system that supports partial caching of shared state information. Moreover, the decisions about what to cache should be made at run-time, so that a single system can support full-caching, no-caching, or any point in between these two extremes based on data update rates, client request rates, and available network and server resources.